/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package br.projecao.time.controle;

import br.projecao.time.ProjetoUsuario;
import br.projecao.time.ProjetoUsuarioPK;
import br.projecao.time.controle.exceptions.IllegalOrphanException;
import br.projecao.time.controle.exceptions.NonexistentEntityException;
import br.projecao.time.controle.exceptions.PreexistingEntityException;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import br.projecao.time.Projeto;
import br.projecao.time.Usuario;
import br.projecao.time.ProjetoUsuarioAtividade;
import java.util.ArrayList;
import java.util.Collection;

/**
 *
 * @author edson.sousa
 */
public class ProjetoUsuarioJpaController {

    public ProjetoUsuarioJpaController() {
        emf = Persistence.createEntityManagerFactory("timePU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(ProjetoUsuario projetoUsuario) throws PreexistingEntityException, Exception {
        if (projetoUsuario.getProjetoUsuarioPK() == null) {
            projetoUsuario.setProjetoUsuarioPK(new ProjetoUsuarioPK());
        }
        if (projetoUsuario.getProjetoUsuarioAtividadeCollection() == null) {
            projetoUsuario.setProjetoUsuarioAtividadeCollection(new ArrayList<ProjetoUsuarioAtividade>());
        }
        projetoUsuario.getProjetoUsuarioPK().setProjeto(projetoUsuario.getProjeto1().getIdProjeto());
        projetoUsuario.getProjetoUsuarioPK().setUsuario(projetoUsuario.getUsuario1().getIdUsuario());
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Projeto projeto1 = projetoUsuario.getProjeto1();
            if (projeto1 != null) {
                projeto1 = em.getReference(projeto1.getClass(), projeto1.getIdProjeto());
                projetoUsuario.setProjeto1(projeto1);
            }
            Usuario usuario1 = projetoUsuario.getUsuario1();
            if (usuario1 != null) {
                usuario1 = em.getReference(usuario1.getClass(), usuario1.getIdUsuario());
                projetoUsuario.setUsuario1(usuario1);
            }
            Collection<ProjetoUsuarioAtividade> attachedProjetoUsuarioAtividadeCollection = new ArrayList<ProjetoUsuarioAtividade>();
            for (ProjetoUsuarioAtividade projetoUsuarioAtividadeCollectionProjetoUsuarioAtividadeToAttach : projetoUsuario.getProjetoUsuarioAtividadeCollection()) {
                projetoUsuarioAtividadeCollectionProjetoUsuarioAtividadeToAttach = em.getReference(projetoUsuarioAtividadeCollectionProjetoUsuarioAtividadeToAttach.getClass(), projetoUsuarioAtividadeCollectionProjetoUsuarioAtividadeToAttach.getProjetoUsuarioAtividadePK());
                attachedProjetoUsuarioAtividadeCollection.add(projetoUsuarioAtividadeCollectionProjetoUsuarioAtividadeToAttach);
            }
            projetoUsuario.setProjetoUsuarioAtividadeCollection(attachedProjetoUsuarioAtividadeCollection);
            em.persist(projetoUsuario);
            if (projeto1 != null) {
                projeto1.getProjetoUsuarioCollection().add(projetoUsuario);
                projeto1 = em.merge(projeto1);
            }
            if (usuario1 != null) {
                usuario1.getProjetoUsuarioCollection().add(projetoUsuario);
                usuario1 = em.merge(usuario1);
            }
            for (ProjetoUsuarioAtividade projetoUsuarioAtividadeCollectionProjetoUsuarioAtividade : projetoUsuario.getProjetoUsuarioAtividadeCollection()) {
                ProjetoUsuario oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionProjetoUsuarioAtividade = projetoUsuarioAtividadeCollectionProjetoUsuarioAtividade.getProjetoUsuario();
                projetoUsuarioAtividadeCollectionProjetoUsuarioAtividade.setProjetoUsuario(projetoUsuario);
                projetoUsuarioAtividadeCollectionProjetoUsuarioAtividade = em.merge(projetoUsuarioAtividadeCollectionProjetoUsuarioAtividade);
                if (oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionProjetoUsuarioAtividade != null) {
                    oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionProjetoUsuarioAtividade.getProjetoUsuarioAtividadeCollection().remove(projetoUsuarioAtividadeCollectionProjetoUsuarioAtividade);
                    oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionProjetoUsuarioAtividade = em.merge(oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionProjetoUsuarioAtividade);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findProjetoUsuario(projetoUsuario.getProjetoUsuarioPK()) != null) {
                throw new PreexistingEntityException("ProjetoUsuario " + projetoUsuario + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(ProjetoUsuario projetoUsuario) throws IllegalOrphanException, NonexistentEntityException, Exception {
        projetoUsuario.getProjetoUsuarioPK().setProjeto(projetoUsuario.getProjeto1().getIdProjeto());
        projetoUsuario.getProjetoUsuarioPK().setUsuario(projetoUsuario.getUsuario1().getIdUsuario());
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            ProjetoUsuario persistentProjetoUsuario = em.find(ProjetoUsuario.class, projetoUsuario.getProjetoUsuarioPK());
            Projeto projeto1Old = persistentProjetoUsuario.getProjeto1();
            Projeto projeto1New = projetoUsuario.getProjeto1();
            Usuario usuario1Old = persistentProjetoUsuario.getUsuario1();
            Usuario usuario1New = projetoUsuario.getUsuario1();
            Collection<ProjetoUsuarioAtividade> projetoUsuarioAtividadeCollectionOld = persistentProjetoUsuario.getProjetoUsuarioAtividadeCollection();
            Collection<ProjetoUsuarioAtividade> projetoUsuarioAtividadeCollectionNew = projetoUsuario.getProjetoUsuarioAtividadeCollection();
            List<String> illegalOrphanMessages = null;
            for (ProjetoUsuarioAtividade projetoUsuarioAtividadeCollectionOldProjetoUsuarioAtividade : projetoUsuarioAtividadeCollectionOld) {
                if (!projetoUsuarioAtividadeCollectionNew.contains(projetoUsuarioAtividadeCollectionOldProjetoUsuarioAtividade)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain ProjetoUsuarioAtividade " + projetoUsuarioAtividadeCollectionOldProjetoUsuarioAtividade + " since its projetoUsuario field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (projeto1New != null) {
                projeto1New = em.getReference(projeto1New.getClass(), projeto1New.getIdProjeto());
                projetoUsuario.setProjeto1(projeto1New);
            }
            if (usuario1New != null) {
                usuario1New = em.getReference(usuario1New.getClass(), usuario1New.getIdUsuario());
                projetoUsuario.setUsuario1(usuario1New);
            }
            Collection<ProjetoUsuarioAtividade> attachedProjetoUsuarioAtividadeCollectionNew = new ArrayList<ProjetoUsuarioAtividade>();
            for (ProjetoUsuarioAtividade projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividadeToAttach : projetoUsuarioAtividadeCollectionNew) {
                projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividadeToAttach = em.getReference(projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividadeToAttach.getClass(), projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividadeToAttach.getProjetoUsuarioAtividadePK());
                attachedProjetoUsuarioAtividadeCollectionNew.add(projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividadeToAttach);
            }
            projetoUsuarioAtividadeCollectionNew = attachedProjetoUsuarioAtividadeCollectionNew;
            projetoUsuario.setProjetoUsuarioAtividadeCollection(projetoUsuarioAtividadeCollectionNew);
            projetoUsuario = em.merge(projetoUsuario);
            if (projeto1Old != null && !projeto1Old.equals(projeto1New)) {
                projeto1Old.getProjetoUsuarioCollection().remove(projetoUsuario);
                projeto1Old = em.merge(projeto1Old);
            }
            if (projeto1New != null && !projeto1New.equals(projeto1Old)) {
                projeto1New.getProjetoUsuarioCollection().add(projetoUsuario);
                projeto1New = em.merge(projeto1New);
            }
            if (usuario1Old != null && !usuario1Old.equals(usuario1New)) {
                usuario1Old.getProjetoUsuarioCollection().remove(projetoUsuario);
                usuario1Old = em.merge(usuario1Old);
            }
            if (usuario1New != null && !usuario1New.equals(usuario1Old)) {
                usuario1New.getProjetoUsuarioCollection().add(projetoUsuario);
                usuario1New = em.merge(usuario1New);
            }
            for (ProjetoUsuarioAtividade projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade : projetoUsuarioAtividadeCollectionNew) {
                if (!projetoUsuarioAtividadeCollectionOld.contains(projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade)) {
                    ProjetoUsuario oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade = projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade.getProjetoUsuario();
                    projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade.setProjetoUsuario(projetoUsuario);
                    projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade = em.merge(projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade);
                    if (oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade != null && !oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade.equals(projetoUsuario)) {
                        oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade.getProjetoUsuarioAtividadeCollection().remove(projetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade);
                        oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade = em.merge(oldProjetoUsuarioOfProjetoUsuarioAtividadeCollectionNewProjetoUsuarioAtividade);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                ProjetoUsuarioPK id = projetoUsuario.getProjetoUsuarioPK();
                if (findProjetoUsuario(id) == null) {
                    throw new NonexistentEntityException("The projetoUsuario with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(ProjetoUsuarioPK id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            ProjetoUsuario projetoUsuario;
            try {
                projetoUsuario = em.getReference(ProjetoUsuario.class, id);
                projetoUsuario.getProjetoUsuarioPK();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The projetoUsuario with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<ProjetoUsuarioAtividade> projetoUsuarioAtividadeCollectionOrphanCheck = projetoUsuario.getProjetoUsuarioAtividadeCollection();
            for (ProjetoUsuarioAtividade projetoUsuarioAtividadeCollectionOrphanCheckProjetoUsuarioAtividade : projetoUsuarioAtividadeCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This ProjetoUsuario (" + projetoUsuario + ") cannot be destroyed since the ProjetoUsuarioAtividade " + projetoUsuarioAtividadeCollectionOrphanCheckProjetoUsuarioAtividade + " in its projetoUsuarioAtividadeCollection field has a non-nullable projetoUsuario field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Projeto projeto1 = projetoUsuario.getProjeto1();
            if (projeto1 != null) {
                projeto1.getProjetoUsuarioCollection().remove(projetoUsuario);
                projeto1 = em.merge(projeto1);
            }
            Usuario usuario1 = projetoUsuario.getUsuario1();
            if (usuario1 != null) {
                usuario1.getProjetoUsuarioCollection().remove(projetoUsuario);
                usuario1 = em.merge(usuario1);
            }
            em.remove(projetoUsuario);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<ProjetoUsuario> findProjetoUsuarioEntities() {
        return findProjetoUsuarioEntities(true, -1, -1);
    }

    public List<ProjetoUsuario> findProjetoUsuarioEntities(int maxResults, int firstResult) {
        return findProjetoUsuarioEntities(false, maxResults, firstResult);
    }

    private List<ProjetoUsuario> findProjetoUsuarioEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(ProjetoUsuario.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public ProjetoUsuario findProjetoUsuario(ProjetoUsuarioPK id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(ProjetoUsuario.class, id);
        } finally {
            em.close();
        }
    }

    public int getProjetoUsuarioCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<ProjetoUsuario> rt = cq.from(ProjetoUsuario.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
